/**
 * 这是一个独立的测试脚本，用于验证环境检测功能，
 * 不依赖于 VSCode API
 */

import { exec } from 'child_process';
import { promisify } from 'util';
import * as http from 'http';
import * as httpProxy from 'http-proxy';
import * as fs from 'fs';
import * as path from 'path';

const execAsync = promisify(exec);

// 简化版的环境检测器
async function detectEnvironment() {
    try {
        // 检测 Podman
        try {
            const { stdout: podmanVersion } = await execAsync('podman --version');
            console.log('Podman 版本:', podmanVersion.trim());
            
            // 检查是否可用
            await execAsync('podman info');
            return { type: 'podman', version: podmanVersion.trim() };
        } catch (error) {
            console.log('Podman 不可用，尝试检测 Docker...');
        }
        
        // 检测 Docker
        try {
            const { stdout: dockerVersion } = await execAsync('docker --version');
            console.log('Docker 版本:', dockerVersion.trim());
            
            // 检查是否可用
            const { stdout: dockerInfo } = await execAsync('docker info');
            const isRootless = dockerInfo.includes('Rootless');
            console.log('Docker Rootless 模式:', isRootless ? '是' : '否');
            
            return { type: 'docker', version: dockerVersion.trim() };
        } catch (error) {
            console.log('Docker 不可用，将使用内置代理...');
        }
        
        // 如果都没有，返回 none
        return { type: 'none' };
    } catch (error) {
        console.error('检测环境时出错:', error);
        return { type: 'none' };
    }
}

// 简化版的代理服务器
class SimpleProxyServer {
    private server: http.Server | null = null;
    private proxy: httpProxy | null = null;
    
    async start(port = 8080) {
        try {
            // 确保代理未运行
            await this.stop();
            
            // 初始化代理
            this.proxy = httpProxy.createProxyServer({});
            
            // 配置并启动服务器
            this.server = http.createServer((req, res) => {
                const url = req.url || '/';
                const target = 'http://localhost:3000'; // 默认目标
                
                console.log(`[Proxy] ${req.method} ${url} -> ${target}`);
                
                // 代理请求
                if (this.proxy) {
                    this.proxy.web(req, res, { target }, (err: Error) => {
                        console.error('[Proxy] Error:', err);
                        
                        res.writeHead(500, { 'Content-Type': 'text/plain' });
                        res.end(`Proxy error: ${err.message}`);
                    });
                }
            });
            
            // 启动 HTTP 服务器
            return new Promise<void>((resolve, reject) => {
                if (!this.server) {
                    return reject(new Error('Server not initialized'));
                }
                
                this.server.listen(port, () => {
                    console.log(`代理服务器已启动，监听端口 ${port}`);
                    resolve();
                });
                
                this.server.on('error', (err) => {
                    reject(err);
                });
            });
        } catch (error) {
            console.error('启动代理服务器失败:', error);
            throw error;
        }
    }
    
    async stop() {
        return new Promise<void>((resolve) => {
            if (this.server) {
                this.server.close(() => {
                    console.log('代理服务器已停止');
                    this.server = null;
                    this.proxy = null;
                    resolve();
                });
            } else {
                resolve();
            }
        });
    }
}

// 运行测试
async function runTests() {
    console.log('========== 开始测试 ==========');
    
    // 1. 测试环境检测
    console.log('\n----- 测试环境检测 -----');
    try {
        console.log('检测环境中...');
        const env = await detectEnvironment();
        console.log('检测结果:', env);
        
        if (env.type === 'podman') {
            console.log('✅ 成功检测到 Podman 环境');
        } else if (env.type === 'docker') {
            console.log('✅ 成功检测到 Docker 环境');
        } else {
            console.log('✅ 未检测到容器环境，将使用内置代理');
        }
    } catch (error) {
        console.error('❌ 环境检测失败:', error);
    }
    
    // 2. 测试代理服务器
    console.log('\n----- 测试代理服务器 -----');
    const proxyServer = new SimpleProxyServer();
    
    try {
        console.log('启动代理服务器...');
        await proxyServer.start(8082); // 使用不常用的端口
        console.log('✅ 代理服务器启动成功');
        
        // 等待一段时间后停止服务器
        console.log('5秒后停止服务器...');
        await new Promise(resolve => setTimeout(resolve, 5000));
        
        await proxyServer.stop();
        console.log('✅ 代理服务器停止成功');
    } catch (error) {
        console.error('❌ 代理服务器测试失败:', error);
    }
    
    console.log('\n========== 测试完成 ==========');
}

runTests().catch(error => {
    console.error('测试过程中发生错误:', error);
}); 